package com.mihuxiaobaigao.ai.utils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.regex.Pattern;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;

public class ImageUtils {

    /**
     * 检查字符串是否为有效的Base64图片数据
     * @param base64Data Base64编码的图片数据
     * @return 如果是有效的Base64图片数据返回true，否则返回false
     */
    public static boolean isValidBase64Image(String base64Data) {
        if (base64Data == null || base64Data.isEmpty()) {
            return false;
        }

        // 检查是否包含常见图片格式的Base64前缀
        String pattern = "^data:image/(png|jpg|jpeg|gif|bmp|webp);base64,";
        return Pattern.compile(pattern).matcher(base64Data).find() ||
                base64Data.length() > 100 && base64Data.matches("^[A-Za-z0-9+/=]+$");
    }

    /**
     * 从Base64数据中提取图片格式
     * @param base64Data Base64编码的图片数据
     * @return 图片格式（如：png, jpg等）
     */
    public static String extractImageFormat(String base64Data) {
        if (base64Data == null || base64Data.isEmpty()) {
            return "png"; // 默认格式
        }

        // 如果包含data URI scheme，从中提取格式
        if (base64Data.startsWith("data:image/")) {
            int startIndex = base64Data.indexOf("image/") + 6;
            int endIndex = base64Data.indexOf(";", startIndex);
            if (endIndex != -1) {
                String format = base64Data.substring(startIndex, endIndex);
                // 统一jpeg为jpg
                return "jpeg".equals(format) ? "jpg" : format;
            }
        }

        // 根据常见Base64特征猜测格式
        if (base64Data.startsWith("/9j/") || base64Data.startsWith("/9j/")) {
            return "jpg";
        } else if (base64Data.startsWith("iVBORw0KGgo")) {
            return "png";
        } else if (base64Data.startsWith("R0lGODlh")) {
            return "gif";
        } else if (base64Data.startsWith("Qk2")) {
            return "bmp";
        }

        return "png"; // 默认格式
    }

    /**
     * 解码Base64图片数据并保存为JPG格式
     * @param base64Data Base64编码的图片数据
     * @param outputPath 输出文件路径（必须以.jpg结尾）
     * @return 如果保存成功返回true，否则返回false
     */
    public static boolean decodeAndSaveAsJpg(String base64Data, String outputPath) {
        if (!isValidBase64Image(base64Data)) {
            System.err.println("无效的Base64图片数据");
            return false;
        }

        // 确保输出路径以.jpg结尾
        if (!outputPath.toLowerCase().endsWith(".jpg") && !outputPath.toLowerCase().endsWith(".jpeg")) {
            outputPath = outputPath + ".jpg";
        }

        try {
            // 清理Base64数据（移除可能的数据URI前缀）
            String cleanedBase64 = cleanBase64Data(base64Data);

            // 解码Base64数据
            byte[] imageData = Base64.getDecoder().decode(cleanedBase64);

            // 读取图片
            ByteArrayInputStream bis = new ByteArrayInputStream(imageData);
            BufferedImage image = ImageIO.read(bis);

            if (image == null) {
                System.err.println("无法解码图片数据");
                return false;
            }

            // 确保输出目录存在
            File outputFile = new File(outputPath);
            File parentDir = outputFile.getParentFile();
            if (parentDir != null && !parentDir.exists()) {
                parentDir.mkdirs();
            }

            // 创建新的RGB图像（确保兼容JPG格式）
            BufferedImage jpgImage = new BufferedImage(
                    image.getWidth(),
                    image.getHeight(),
                    BufferedImage.TYPE_INT_RGB
            );

            // 绘制原始图像到新的RGB图像（处理透明背景）
            jpgImage.createGraphics().drawImage(image, 0, 0, null);

            // 保存为JPG格式
            ImageIO.write(jpgImage, "jpg", outputFile);

            System.out.println("图片已成功保存为JPG格式: " + outputPath);
            return true;

        } catch (IOException e) {
            System.err.println("保存图片时发生IO异常: " + e.getMessage());
            return false;
        } catch (IllegalArgumentException e) {
            System.err.println("Base64数据格式错误: " + e.getMessage());
            return false;
        }
    }

    /**
     * 解码Base64图片数据，如果不是JPG格式则转换为JPG
     * @param base64Data Base64编码的图片数据
     * @param outputPath 输出文件路径
     * @return 如果保存成功返回true，否则返回false
     */
    public static boolean decodeAndSaveImage(String base64Data, String outputPath) {
        String originalFormat = extractImageFormat(base64Data);

        // 如果原始格式不是JPG，则转换为JPG
        if (!"jpg".equalsIgnoreCase(originalFormat)) {
            System.out.println("检测到非JPG格式(" + originalFormat + ")，将转换为JPG格式");
            return decodeAndSaveAsJpg(base64Data, outputPath);
        }

        // 如果是JPG格式，直接保存
        try {
            // 清理Base64数据
            String cleanedBase64 = cleanBase64Data(base64Data);

            // 解码Base64数据
            byte[] imageData = Base64.getDecoder().decode(cleanedBase64);

            // 确保输出目录存在
            File outputFile = new File(outputPath);
            File parentDir = outputFile.getParentFile();
            if (parentDir != null && !parentDir.exists()) {
                parentDir.mkdirs();
            }

            // 直接写入文件（已经是JPG格式）
            try (FileOutputStream fos = new FileOutputStream(outputFile)) {
                fos.write(imageData);
            }

            System.out.println("JPG图片已成功保存: " + outputPath);
            return true;

        } catch (IOException e) {
            System.err.println("保存图片时发生IO异常: " + e.getMessage());
            return false;
        } catch (IllegalArgumentException e) {
            System.err.println("Base64数据格式错误: " + e.getMessage());
            return false;
        }
    }

    /**
     * 清理Base64数据，移除数据URI前缀
     * @param base64Data 原始Base64数据
     * @return 清理后的Base64数据
     */
    private static String cleanBase64Data(String base64Data) {
        if (base64Data.startsWith("data:image/")) {
            int base64Index = base64Data.indexOf("base64,");
            if (base64Index != -1) {
                return base64Data.substring(base64Index + 7);
            }
        }
        return base64Data;
    }

    /**
     * 解码Base64图片数据并自动生成文件名保存，非JPG格式转换为JPG
     * @param base64Data Base64编码的图片数据
     * @param directory 保存目录
     * @param fileName 文件名（不包含扩展名）
     * @return 保存的文件路径，如果失败返回null
     */
    public static String decodeAndSaveImage(String base64Data, String directory, String fileName) {
        String filePath = directory + File.separator + fileName + ".jpg";

        if (decodeAndSaveImage(base64Data, filePath)) {
            return filePath;
        }
        return null;
    }

    /**
     * 直接转换为JPG格式并保存（忽略原始格式）
     * @param base64Data Base64编码的图片数据
     * @param directory 保存目录
     * @param fileName 文件名（不包含扩展名）
     * @return 保存的文件路径，如果失败返回null
     */
    public static String decodeAndSaveAsJpg(String base64Data, String directory, String fileName) {
        String filePath = directory + File.separator + fileName + ".jpg";

        if (decodeAndSaveAsJpg(base64Data, filePath)) {
            return filePath;
        }
        return null;
    }

    /**
     * 读取图片文件并转换为Base64编码字符串
     * @param filePath 图片文件的完整路径
     * @return Base64编码的字符串
     * @throws IOException 如果文件读取失败
     */
    public static String imageToBase64(String filePath) throws IOException {
        // 读取文件内容为字节数组

        byte[] fileContent = Files.readAllBytes(Paths.get(filePath));
        // 进行Base64编码并返回
        return Base64.getEncoder().encodeToString(fileContent);
    }
}